package UnitTest;

import Roteamento.Enlace;
import Roteamento.TabelaRoteamento;
import Roteamento.VetorRoteamento;
import junit.framework.TestCase;

public class TabelaRoteamentoTest extends TestCase{

	private TabelaRoteamento tabelaA;
	
	public void setUp(){
		
		Enlace enlace1 = new Enlace("A", "B", 2);
		Enlace enlace2 = new Enlace("C", "A", 4);
		Enlace[] enlaceList = { enlace1, enlace2 };
		
		tabelaA = new TabelaRoteamento("A", enlaceList);
	}
	
	public void testCreateTable() {
		
		assertNotNull(tabelaA);
		
		assertEquals(3, tabelaA.getVizinhos().size());
		
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(3, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
				
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "C"));
		
		VetorRoteamento vetorInicial =  tabelaA.getDadosASeremEnviados();
		assertEquals("A", vetorInicial.getFonte());
		assertEquals(3, vetorInicial.getDestinosAlcancaveis().size());
		assertEquals("A", vetorInicial.getDestinosAlcancaveis().get(0));
		assertEquals("B", vetorInicial.getDestinosAlcancaveis().get(1));
		assertEquals("C", vetorInicial.getDestinosAlcancaveis().get(2));
		assertEquals(0, vetorInicial.getMenorCusto("A"));
		assertEquals(2, vetorInicial.getMenorCusto("B"));
		assertEquals(4, vetorInicial.getMenorCusto("C"));
	}
	
	public void testUpdateTable(){
				
		//recebendo uma atualizacao do roteador B		
		VetorRoteamento vetorRoteamento = new VetorRoteamento("B");
		vetorRoteamento.updateDestino("A", 2);
		vetorRoteamento.updateDestino("B", 0);
		vetorRoteamento.updateDestino("D", 2);
		
		assertTrue(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(4, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "D"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "C"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "D"));
		
		VetorRoteamento vetorASerEnviado = tabelaA.getDadosASeremEnviados();
		assertEquals("A", vetorASerEnviado.getFonte());
		assertEquals(4, vetorASerEnviado.getDestinosAlcancaveis().size());
		assertEquals("A", vetorASerEnviado.getDestinosAlcancaveis().get(0));
		assertEquals("B", vetorASerEnviado.getDestinosAlcancaveis().get(1));
		assertEquals("C", vetorASerEnviado.getDestinosAlcancaveis().get(2));
		assertEquals("D", vetorASerEnviado.getDestinosAlcancaveis().get(3));
		assertEquals(0, vetorASerEnviado.getMenorCusto("A"));
		assertEquals(2, vetorASerEnviado.getMenorCusto("B"));
		assertEquals(4, vetorASerEnviado.getMenorCusto("C"));
		assertEquals(4, vetorASerEnviado.getMenorCusto("D"));
		
		
		//recebendo uma atualizacao do roteador C
		vetorRoteamento = new VetorRoteamento("C");
		vetorRoteamento.updateDestino("A", 4);
		vetorRoteamento.updateDestino("C", 0);
		vetorRoteamento.updateDestino("D", 3);
		
		assertFalse(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(4, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		vetorASerEnviado = tabelaA.getDadosASeremEnviados();
		assertEquals("A", vetorASerEnviado.getFonte());
		assertEquals(4, vetorASerEnviado.getDestinosAlcancaveis().size());
		assertEquals("A", vetorASerEnviado.getDestinosAlcancaveis().get(0));
		assertEquals("B", vetorASerEnviado.getDestinosAlcancaveis().get(1));
		assertEquals("C", vetorASerEnviado.getDestinosAlcancaveis().get(2));
		assertEquals("D", vetorASerEnviado.getDestinosAlcancaveis().get(3));
		assertEquals(0, vetorASerEnviado.getMenorCusto("A"));
		assertEquals(2, vetorASerEnviado.getMenorCusto("B"));
		assertEquals(4, vetorASerEnviado.getMenorCusto("C"));
		assertEquals(4, vetorASerEnviado.getMenorCusto("D"));
	}
	
	public void testAddNewVizinhoAndRemoveVizinho(){
		
		//PASS0 1 - CRIAR TABELA "A" LIGADO APENAS A "C", OU SEJA,
		//SEM SABER DA EXISTENCIA DA LIGICAO DE "A" PARA "B"
		Enlace enlace1 = new Enlace("C", "A", 4);
		Enlace[] enlaceList = { enlace1 };
		
		tabelaA = new TabelaRoteamento("A", enlaceList);
		
		assertEquals(2, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("C", tabelaA.getVizinhos().get(1));
		
		assertEquals(2, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(1));
				
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "C"));
		
				
		//PASSO 2 - "C" ENVIA PRIMEIRA MENSAGEM A "A" 
		//E "A" TOMA NOTA DA EXISTENCIA DE "D"
		VetorRoteamento vetorRoteamento = new VetorRoteamento("C");
		vetorRoteamento.updateDestino("A", 4);
		vetorRoteamento.updateDestino("C", 0);
		vetorRoteamento.updateDestino("D", 3);
			
		assertTrue(tabelaA.update(vetorRoteamento));
		
		assertEquals(2, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("C", tabelaA.getVizinhos().get(1));
		
		assertEquals(3, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(2));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(7, tabelaA.getMenorCusto("A", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		//PASSO 3 - O ROTEADOR "B" E LIGADO, LOGO "A" DEVE RECONHECER SEU NOVO VIZINHO
		//AO ADICIONAR UM NOVO VIZINHO DEVE SER PASSADO COMO PARAMETRO O CUSTO DO ENLACE
		tabelaA.adicionaNovoVizinho("B", 2);
		
		assertEquals(3, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(7, tabelaA.getMenorCusto("A", "D"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		//PASSO 4 - O ROTEADOR "B" MANDA A PRIMEIRA MENSAGEM PARA "A" 
		//"A" DEVE RECONHECER UM CAMINHO MELHOR PARA "D"
		vetorRoteamento = new VetorRoteamento("B");
		vetorRoteamento.updateDestino("A", 2);
		vetorRoteamento.updateDestino("B", 0);
		vetorRoteamento.updateDestino("C", 5);
		vetorRoteamento.updateDestino("D", 2);
		
		assertTrue(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(4, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(5, tabelaA.getMenorCusto("B", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		//PASSO 5 - VAMOS DESATIVAR O ROTEADOR "C"
		tabelaA.removerVizinho("C");
		
		assertEquals(2, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(7, tabelaA.getMenorCusto("A", "C"));
		assertEquals(4, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(5, tabelaA.getMenorCusto("B", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "D"));
		
		//PASSO 6 - REATIVAR "C" PARA QUE A TABELA DE "A" VOLTA AO
		//ESTADO ANTERIOR DO PASSO 5	
		tabelaA.adicionaNovoVizinho("C", 4);
		
		vetorRoteamento = new VetorRoteamento("C");
		vetorRoteamento.updateDestino("A", 4);
		vetorRoteamento.updateDestino("C", 0);
		vetorRoteamento.updateDestino("D", 3);
			
		assertFalse(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(4, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(5, tabelaA.getMenorCusto("B", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		//PASSO 7 - "D" FOI DESLIGADO
		//"B" E "C" QUE SAO VIZINHOS A "D" JA OBSERVARAM O OCORRIDO
		//AMBOS VAO MANDAR PARA "A" AS RESPECTIVAS TABELAS
		//E "A" TEM QUE NOTAR QUE "D" NAO E MAIS ALCANCAVEL
		
		//PASSO7.1 - "B" ENVIA PRA "A" SUA NOVA TABELA
		vetorRoteamento = new VetorRoteamento("B");
		vetorRoteamento.updateDestino("A", 2);
		vetorRoteamento.updateDestino("B", 0);
		
		assertTrue(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(7, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		//PASSO7.2 - "C" ENVIA PRA "A" SUA NOVA TABELA
		vetorRoteamento = new VetorRoteamento("C");
		vetorRoteamento.updateDestino("A", 4);
		vetorRoteamento.updateDestino("C", 0);
			
		assertTrue(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(3, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		
		//verifica o vetor do dados a ser enviado por "A"
		//este vetor nao deve conter informacoes sobre o roteador "D"
		VetorRoteamento vetorASerEnviado = tabelaA.getDadosASeremEnviados();
		assertEquals("A", vetorASerEnviado.getFonte());
		assertEquals(4, vetorASerEnviado.getDestinosAlcancaveis().size());
		assertEquals("A", vetorASerEnviado.getDestinosAlcancaveis().get(0));
		assertEquals("B", vetorASerEnviado.getDestinosAlcancaveis().get(1));
		assertEquals("C", vetorASerEnviado.getDestinosAlcancaveis().get(2));
		assertEquals("D", vetorASerEnviado.getDestinosAlcancaveis().get(3));
		assertEquals(0, vetorASerEnviado.getMenorCusto("A"));
		assertEquals(2, vetorASerEnviado.getMenorCusto("B"));
		assertEquals(4, vetorASerEnviado.getMenorCusto("C"));
		assertEquals(1000, vetorASerEnviado.getMenorCusto("D"));
	}
	
	public void testeRemoveVizinho2(){
		//new teste usaremos a seguintes topologia de rede
		// A-B custo=2; A-C custo=7; B-C custo=3
		//faremos a tabela convergir logo A achara um menor caminho para C via B
		//depois removeremos B e tanto A como C devem ser capazes de achar o menor
		//caminho entre si com custo 7
		
		Enlace enlace1 = new Enlace("A", "B", 2);
		Enlace enlace2 = new Enlace("A", "C", 7);
		Enlace enlace3 = new Enlace("B", "C", 3);
		Enlace[] enlaces = {enlace1, enlace2, enlace3};
		TabelaRoteamento tabelaA = new TabelaRoteamento("A", enlaces);
		TabelaRoteamento tabelaB = new TabelaRoteamento("B", enlaces);
		TabelaRoteamento tabelaC = new TabelaRoteamento("C", enlaces);
		
		//PRIMEIRA ATUALIZACAO
		assertTrue(tabelaA.update(tabelaB.getDadosASeremEnviados()));
		assertFalse(tabelaA.update(tabelaC.getDadosASeremEnviados()));
		
		assertFalse(tabelaB.update(tabelaA.getDadosASeremEnviados()));
		assertFalse(tabelaB.update(tabelaC.getDadosASeremEnviados()));
		
		assertFalse(tabelaC.update(tabelaA.getDadosASeremEnviados()));
		assertTrue(tabelaC.update(tabelaB.getDadosASeremEnviados()));
		
		//tabela A apos a primeira atualizacao
		assertEquals(3, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(3, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
				
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(5, tabelaA.getMenorCusto("A", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(3, tabelaA.getMenorCusto("B", "C"));
		assertEquals(7, tabelaA.getMenorCusto("C", "A"));
		assertEquals(3, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		
		//tabela B apos a primeira atualizacao
		assertEquals(3, tabelaB.getVizinhos().size());
		assertEquals("A", tabelaB.getVizinhos().get(0));
		assertEquals("B", tabelaB.getVizinhos().get(1));
		assertEquals("C", tabelaB.getVizinhos().get(2));
		
		assertEquals(3, tabelaB.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaB.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaB.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaB.getDestinosAlcancaveis().get(2));
				
		assertEquals(0, tabelaB.getMenorCusto("A", "A"));
		assertEquals(2, tabelaB.getMenorCusto("A", "B"));
		assertEquals(5, tabelaB.getMenorCusto("A", "C"));
		assertEquals(2, tabelaB.getMenorCusto("B", "A"));
		assertEquals(0, tabelaB.getMenorCusto("B", "B"));
		assertEquals(3, tabelaB.getMenorCusto("B", "C"));
		assertEquals(7, tabelaB.getMenorCusto("C", "A"));
		assertEquals(3, tabelaB.getMenorCusto("C", "B"));
		assertEquals(0, tabelaB.getMenorCusto("C", "C"));
		
		//tabela C apos a primeira atualizacao
		assertEquals(3, tabelaC.getVizinhos().size());
		assertEquals("A", tabelaC.getVizinhos().get(0));
		assertEquals("B", tabelaC.getVizinhos().get(1));
		assertEquals("C", tabelaC.getVizinhos().get(2));
		
		assertEquals(3, tabelaC.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaC.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaC.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaC.getDestinosAlcancaveis().get(2));
				
		assertEquals(0, tabelaC.getMenorCusto("A", "A"));
		assertEquals(2, tabelaC.getMenorCusto("A", "B"));
		assertEquals(5, tabelaC.getMenorCusto("A", "C"));
		assertEquals(2, tabelaC.getMenorCusto("B", "A"));
		assertEquals(0, tabelaC.getMenorCusto("B", "B"));
		assertEquals(3, tabelaC.getMenorCusto("B", "C"));
		assertEquals(5, tabelaC.getMenorCusto("C", "A"));
		assertEquals(3, tabelaC.getMenorCusto("C", "B"));
		assertEquals(0, tabelaC.getMenorCusto("C", "C"));
		
		//SEGUNDA ATUALIZACAO
		//NESTE PONTO AS TABELAS CONVERGIRAM
		assertFalse(tabelaA.update(tabelaB.getDadosASeremEnviados()));
		assertFalse(tabelaA.update(tabelaC.getDadosASeremEnviados()));
		
		assertFalse(tabelaB.update(tabelaA.getDadosASeremEnviados()));
		assertFalse(tabelaB.update(tabelaC.getDadosASeremEnviados()));
		
		assertFalse(tabelaC.update(tabelaA.getDadosASeremEnviados()));
		assertFalse(tabelaC.update(tabelaB.getDadosASeremEnviados()));
		
		//REMOVENDO B DAS DUAS TABELAS
		tabelaA.removerVizinho("B");
		
		assertEquals(2, tabelaA.getVizinhos().size());
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("C", tabelaA.getVizinhos().get(1));
		
		assertEquals(3, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
				
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(10, tabelaA.getMenorCusto("A", "B"));
		assertEquals(7, tabelaA.getMenorCusto("A", "C"));
		assertEquals(5, tabelaA.getMenorCusto("C", "A"));
		assertEquals(3, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
	}
	
	public void testEnlaces(){
		//testando a configuracao do setUp		
		assertEquals(2, tabelaA.getEnlaces().size());
		assertTrue(tabelaA.getEnlaces().get(0).containsRoteador("A"));
		assertTrue(tabelaA.getEnlaces().get(0).containsRoteador("B"));
		assertEquals(2, tabelaA.getEnlaces().get(0).getCusto());
		assertTrue(tabelaA.getEnlaces().get(1).containsRoteador("A"));
		assertTrue(tabelaA.getEnlaces().get(1).containsRoteador("C"));
		assertEquals(4, tabelaA.getEnlaces().get(1).getCusto());
		
		//adicionando um vizinho um novo enlace deve ser gerado
		tabelaA.adicionaNovoVizinho("D", 9);
		assertEquals(3, tabelaA.getEnlaces().size());
		assertTrue(tabelaA.getEnlaces().get(2).containsRoteador("A"));
		assertTrue(tabelaA.getEnlaces().get(2).containsRoteador("D"));
		assertEquals(9, tabelaA.getEnlaces().get(2).getCusto());
		
		//removendo o vizinho, o enlace ate aquele vizinho deve ser removido
		tabelaA.removerVizinho("B");
		assertEquals(2, tabelaA.getEnlaces().size());
		assertTrue(tabelaA.getEnlaces().get(0).containsRoteador("A"));
		assertTrue(tabelaA.getEnlaces().get(0).containsRoteador("C"));
		assertEquals(4, tabelaA.getEnlaces().get(0).getCusto());
		assertTrue(tabelaA.getEnlaces().get(1).containsRoteador("A"));
		assertTrue(tabelaA.getEnlaces().get(1).containsRoteador("D"));
		assertEquals(9, tabelaA.getEnlaces().get(1).getCusto());
		
		//tentando remover um vizinho que nao existe
		tabelaA.removerVizinho("Z");
		assertEquals(2, tabelaA.getEnlaces().size());
				
	}

    
	public void testToStringVetorRoteamento(){
		VetorRoteamento vetorRoteamento = new VetorRoteamento("C");
		vetorRoteamento.updateDestino("A", 4);
		vetorRoteamento.updateDestino("C", 0);
		vetorRoteamento.updateDestino("D", 3);
		assertEquals("#nome:C#A:4#C:0#D:3#", vetorRoteamento.toString());
		
		vetorRoteamento = new VetorRoteamento("#nome:C#A:4#C:0#D:3#");
		assertEquals("C", vetorRoteamento.getFonte());
		assertEquals(3, vetorRoteamento.getDestinosAlcancaveis().size());
		assertEquals("A", vetorRoteamento.getDestinosAlcancaveis().get(0));
		assertEquals("C", vetorRoteamento.getDestinosAlcancaveis().get(1));
		assertEquals("D", vetorRoteamento.getDestinosAlcancaveis().get(2));
		assertEquals(4, vetorRoteamento.getMenorCusto("A"));
		assertEquals(0, vetorRoteamento.getMenorCusto("C"));
		assertEquals(3, vetorRoteamento.getMenorCusto("D"));
	}
	
	public void testGetTableToView(){
		VetorRoteamento vetorRoteamento = new VetorRoteamento("B");
		vetorRoteamento.updateDestino("A", 2);
		vetorRoteamento.updateDestino("B", 0);
		vetorRoteamento.updateDestino("D", 2);
		
		assertTrue(tabelaA.update(vetorRoteamento));
		
		vetorRoteamento = new VetorRoteamento("C");
		vetorRoteamento.updateDestino("A", 4);
		vetorRoteamento.updateDestino("C", 0);
		vetorRoteamento.updateDestino("D", 3);
		
		assertFalse(tabelaA.update(vetorRoteamento));
		
		assertEquals(3, tabelaA.getVizinhos().size());
		
		assertEquals("A", tabelaA.getVizinhos().get(0));
		assertEquals("B", tabelaA.getVizinhos().get(1));
		assertEquals("C", tabelaA.getVizinhos().get(2));
		
		assertEquals(4, tabelaA.getDestinosAlcancaveis().size());
		assertEquals("A", tabelaA.getDestinosAlcancaveis().get(0));
		assertEquals("B", tabelaA.getDestinosAlcancaveis().get(1));
		assertEquals("C", tabelaA.getDestinosAlcancaveis().get(2));
		assertEquals("D", tabelaA.getDestinosAlcancaveis().get(3));
		
		assertEquals(0, tabelaA.getMenorCusto("A", "A"));
		assertEquals(2, tabelaA.getMenorCusto("A", "B"));
		assertEquals(4, tabelaA.getMenorCusto("A", "C"));
		assertEquals(4, tabelaA.getMenorCusto("A", "D"));
		assertEquals(2, tabelaA.getMenorCusto("B", "A"));
		assertEquals(0, tabelaA.getMenorCusto("B", "B"));
		assertEquals(1000, tabelaA.getMenorCusto("B", "C"));
		assertEquals(2, tabelaA.getMenorCusto("B", "D"));
		assertEquals(4, tabelaA.getMenorCusto("C", "A"));
		assertEquals(1000, tabelaA.getMenorCusto("C", "B"));
		assertEquals(0, tabelaA.getMenorCusto("C", "C"));
		assertEquals(3, tabelaA.getMenorCusto("C", "D"));
		
		String[][] tabelaToView = tabelaA.getTabelaComoMatriz();
		
		assertEquals(12, tabelaToView.length);
		assertEquals(3, tabelaToView[0].length);
		assertEquals("A", tabelaToView[0][0]);
		assertEquals("A", tabelaToView[0][1]);
		assertEquals("0", tabelaToView[0][2]);
		assertEquals(3, tabelaToView[1].length);
		assertEquals("A", tabelaToView[1][0]);
		assertEquals("B", tabelaToView[1][1]);
		assertEquals("2", tabelaToView[1][2]);
		assertEquals(3, tabelaToView[2].length);
		assertEquals("A", tabelaToView[2][0]);
		assertEquals("C", tabelaToView[2][1]);
		assertEquals("4", tabelaToView[2][2]);
		assertEquals(3, tabelaToView[3].length);
		assertEquals("A", tabelaToView[3][0]);
		assertEquals("D", tabelaToView[3][1]);
		assertEquals("4", tabelaToView[3][2]);
		assertEquals(3, tabelaToView[4].length);
		assertEquals("B", tabelaToView[4][0]);
		assertEquals("A", tabelaToView[4][1]);
		assertEquals("2", tabelaToView[4][2]);
		assertEquals(3, tabelaToView[5].length);
		assertEquals("B", tabelaToView[5][0]);
		assertEquals("B", tabelaToView[5][1]);
		assertEquals("0", tabelaToView[5][2]);
		assertEquals(3, tabelaToView[6].length);
		assertEquals("B", tabelaToView[6][0]);
		assertEquals("C", tabelaToView[6][1]);
		assertEquals(Integer.toString(1000), tabelaToView[6][2]);
		assertEquals(3, tabelaToView[7].length);
		assertEquals("B", tabelaToView[7][0]);
		assertEquals("D", tabelaToView[7][1]);
		assertEquals("2", tabelaToView[7][2]);
		assertEquals(3, tabelaToView[8].length);
		assertEquals("C", tabelaToView[8][0]);
		assertEquals("A", tabelaToView[8][1]);
		assertEquals("4", tabelaToView[8][2]);
		assertEquals(3, tabelaToView[9].length);
		assertEquals("C", tabelaToView[9][0]);
		assertEquals("B", tabelaToView[9][1]);
		assertEquals(Integer.toString(1000), tabelaToView[9][2]);
		assertEquals(3, tabelaToView[10].length);
		assertEquals("C", tabelaToView[10][0]);
		assertEquals("C", tabelaToView[10][1]);
		assertEquals("0", tabelaToView[10][2]);
		assertEquals(3, tabelaToView[11].length);
		assertEquals("C", tabelaToView[11][0]);
		assertEquals("D", tabelaToView[11][1]);
		assertEquals("3", tabelaToView[11][2]);
		
	}	
}

